class ItauTransfer
  #attr_accessor :itireg,:ititra,:icdsrv,:ictdeb,:ibcocr,:ictcre,:itcrdb,:imoned,:imtotr,:imtot2,:inrodo,:itifac,:inrfac,:inrcuo,:ifchcr,:ifchc2,:icepto,:inrref,:ifecca,:ihorca,:iusuca
  attr_accessor :tipo_registro,:tipo_transferencia,:codigo_empresa,:cuenta_debito_empresa,:numero_banco_credito,:cuenta_credito
  attr_accessor :tipo,:orden_cheque,:moneda,:monto_primero,:monto_segundo,:documento_persona,:tipo_factura,:numero_factura,:numero_cuota
  attr_accessor :fecha_credito_primera,:fecha_credito_segunda,:comentario,:referencia_operacion,:fecha_carga,:hora_carga,:nombre_usuario
  attr_accessor :movimientos,:registros,:ultimo_registro,:movimientos_con_error,:total
  attr_accessor :detalle_de_registros
  alias :itireg :tipo_registro
  alias :ititra :tipo_transferencia
  alias :icdsrv :codigo_empresa
  alias :ictdeb :cuenta_debito_empresa
  alias :ibcocr :numero_banco_credito
  alias :ictcre :cuenta_credito
  alias :itcrdb :tipo
  alias :iorden :orden_cheque
  alias :imoned :moneda
  alias :imtotr :monto_primero
  alias :imtot2 :monto_segundo
  alias :inrodo :documento_persona
  alias :itifac :tipo_factura
  alias :inrfac :numero_factura
  alias :inrcuo :numero_cuota
  alias :ifchcr :fecha_credito_primera
  alias :ifchc2 :fecha_credito_segunda
  alias :icepto :comentario
  alias :inrref :referencia_operacion
  alias :ifecca :fecha_carga
  alias :ihorca :hora_carga
  alias :iusuca :nombre_usuario


  CamposRegistroOrden=[:itireg,:ititra,:icdsrv,:ictdeb,:ibcocr,:ictcre,:itcrdb,:iorden,:imoned,
    :imtotr,:imtot2,:inrodo,:itifac,:inrfac,:inrcuo,:ifchcr,:ifchc2,
    :icepto,:inrref,:ifecca,:ihorca,:iusuca]
  
  #ITIREG: TIPO DE REGISTRO ENVIADO
  TipoRegistro={:type=>:alfa,:size=>1,:values=>{:detalle=>'D',:control=>'C'},:posi=>1,:posf=>1,:required=>true,:filling_char=>' ',:desc=>'ITIREG: TIPO DE REGISTRO ENVIADO'}

  #ITITRA: TIPO TRANSFERENCIA
  TipoTransferencia={:type=>:alfa,:size=>2,:values=>{:pago_salarios=>'01',:pago_proveedores=>'02',:cobro_facturas=>'03',:cobro_cuotas=>'03'},:posi=>2,:posf=>3,:required=>true,:filling_char=>' ',:desc=>'ITITRA: TIPO TRANSFERENCIA'}
 
  #ICDSRV: CODIGO EMPRESA (ASIGNADO POR EL BANCO)
  CodigoEmpresa={:type=>:numeric,:size=>3,:decimals=>0,:posi=>4,:posf=>6,:required=>true,:filling_char=>'0',:desc=>'ICDSRV: CODIGO EMPRESA (ASIGNADO POR EL BANCO)'}
 
  #ICTDEB: NRO DE CUENTA PARA DEBITO / CUENTA EMPRESA 
  CuentaDebitoEmpresa={:type=>:numeric,:size=>10,:decimals=>0,:posi=>7,:posf=>16,:required=>true,:filling_char=>'0',:desc=>'ICTDEB: NRO DE CUENTA PARA DEBITO / CUENTA EMPRESA '}
 
  #IBCOCR: NRO DE BANCO PARA CREDITO, OBS: SIEMPRE 017
  NumeroBancoCredito={:type=>:numeric,:size=>3,:value=>'017',:decimals=>0,:posi=>17,:posf=>19,:required=>true,:filling_char=>'0',:desc=>'IBCOCR: NRO DE BANCO PARA CREDITO, OBS: SIEMPRE 017'}
 
  #ICTCRE: NRO DE CUENTA PARA CREDITO, OBS: SI PAGO EN CHEQUES RELLENO CON CEROS
  CuentaCredito={:type=>:numeric,:size=>10,:decimals=>0,:posi=>20,:posf=>29,:required=>true,:filling_char=>'0',:desc=>'ICTCRE: NRO DE CUENTA PARA CREDITO, OBS: SI PAGO EN CHEQUES RELLENO CON CEROS'}
 
  #ITCRDB: TIPO DEBITO/CREDITO, 'D' DEBITO, 'C' CREDITO, 'H' CHEQUE, 'F' COBRO DE FACTURA/CUOTA
  Tipo={:type=>:alfa,:size=>1,:values=>{:debito=>'D',:credito=>'C',:cheque=>'H',:cobro_factura=>'F',:cobro_cuota=>'F'},:required=>true,:posi=>30,:posf=>30,:filling_char=>' ',:desc=>"ITCRDB: TIPO DEBITO/CREDITO, 'D' DEBITO, 'C' CREDITO, 'H' CHEQUE, 'F' COBRO DE FACTURA/CUOTA"}
 
  #IORDEN: CHEQUE A LA ORDEN DE: CLIENTE, FACTURADO, BENEFICIARIO
  #EL CAMPO ES REQUERIDO SI ES UN PAGO A PROVEEDORES, NO EN LOS DEMAS CASOS
  OrdenCheque={:type=>:alfa,:size=>50,:posi=>31,:posf=>80,:required=>{:proveedores=>true,:else=>false},:filling_char=>' ',:desc=>'IORDEN: CHEQUE A LA ORDEN DE: CLIENTE, FACTURADO, BENEFICIARIO. EL CAMPO ES REQUERIDO SI ES UN PAGO A PROVEEDORES, NO EN LOS DEMAS CASOS'}
  
  #IMONED: MONEDA CORRESPONDIENTE AL MONTO, 0 GUARANIES, 1 DOLARES
  #OBS: OARA TRANSFERENCIAS LA CUENTA ORIGEN DEBE SER DE LA MISMA MONEDA QUE LA CUENTA DESTINO
  Moneda={:type=>:numeric,:size=>1,:values=>{:dolares=>'1',:guaranies=>'0'},:decimals=>0,:posi=>81,:posf=>81,:required=>true,:filling_char=>'0',:desc=>'IMONED: MONEDA CORRESPONDIENTE AL MONTO, 0 GUARANIES, 1 DOLARES. OBS: PARA TRANSFERENCIAS LA CUENTA ORIGEN DEBE SER DE LA MISMA MONEDA QUE LA CUENTA DESTINO'}
  
  #IMTOTR: TRANSFERENCIA / MONTO FACTURA, CUOTA
  #OBS: ULTIMOS DOS DIGITOS CORRESPONDE A DECIMALES
  MontoPrimero={:type=>:numeric,:size=>15,:decimals=>2,:posi=>82,:posf=>96,:required=>true,:filling_char=>'0',:desc=>'IMTOTR: TRANSFERENCIA / MONTO FACTURA, CUOTA, OBS: ULTIMOS DOS DIGITOS CORRESPONDE A DECIMALES'}
  
  #IMTOT2: TRANSFERENCIA (SEGUNDO VENCIMIENTO)
  #OBS: ULTIMOS DOS DIGITOS CORRESPONDE A DECIMALES. SOLO PARA 'F' COBRO DE FACTURAS / CUOTA. DEMAS 0
  MontoSegundo={:type=>:numeric,:size=>15,:decimals=>2,:posi=>97,:posf=>111,:required=>false,:filling_char=>'0',:desc=>"IMTOT2: TRANSFERENCIA (SEGUNDO VENCIMIENTO). OBS: ULTIMOS DOS DIGITOS CORRESPONDE A DECIMALES. SOLO PARA 'F' COBRO DE FACTURAS / CUOTA. DEMAS 0"}
  
  #INRODO: NRO DE DOCUMENTO
  #OBS: CEDULA DE IDENTIDAD, RUC, PASAPORTE, OTROS. DEL BENEFICIARIO, PROVEEDOR, CLIENTE  
  DocumentoPersona={:type=>:alfa,:size=>12,:posi=>112,:posf=>123,:required=>{:proveedores=>true,:else=>false},:filling_char=>' ',:desc=>'INRODO: NRO DE DOCUMENTO. OBS: CEDULA DE IDENTIDAD, RUC, PASAPORTE, OTROS. DEL BENEFICIARIO, PROVEEDOR, CLIENTE'}

  #ITIFAC: TIPO FACTURA: 1 FACTURA CONTADO, 2 FACTURA CREDITO
  #OBS: SOLO PARA PAGO PROVEEDORES, DEMAS 0  
  TipoFactura={:type=>:numeric,:size=>1,:values=>{:credito=>'2',:contado=>'1'},:posi=>124,:posf=>124,:required=>{:proveedores=>true,:else=>false},:filling_char=>'0',:desc=>'ITIFAC: TIPO FACTURA: 1 FACTURA CONTADO, 2 FACTURA CREDITO. OBS: SOLO PARA PAGO PROVEEDORES, DEMAS 0'}

  #INRFAC: NRO DE FACTURA
  #OBS: PARA PAGO A PROVEEDORES, DEMAS EN BLANCO  
  NumeroFactura={:type=>:alfa,:size=>10,:posi=>125,:posf=>134,:required=>{:else=>true,:pago_salario=>false},:filling_char=>' ',:desc=>'INRFAC: NRO DE FACTURA. OBS: PARA PAGO A PROVEEDORES, DEMAS EN BLANCO'}

  #INRCUO: NRO DE CUOTA PAGADA / A COBRAR. 
  #SOLO PARA 'F' COBRO DE FACTURA / CUOTA  
  NumeroCuota={:type=>:numeric,:size=>3,:decimals=>0,:posi=>135,:posf=>137,:required=>{:cobro_factura=>true,:else=>false},:filling_char=>'0',:desc=>"INRCUO: NRO DE CUOTA PAGADA / A COBRAR. SOLO PARA 'F' COBRO DE FACTURA / CUOTA  "}

  #IFCHCR: FECHA PARA REALIZAR EL CREDITO / FECHA VENCIMIENTO.  
  FechaCreditoPrimera={:type=>:numeric,:size=>8,:decimals=>0,:posi=>138,:posf=>145,:required=>true,:format=>'%Y%m%d',:filling_char=>'0',:desc=>'IFCHCR: FECHA PARA REALIZAR EL CREDITO / FECHA VENCIMIENTO'}

  #IFCHC2: FECHA SEGUNDO VENCIMIENTO.
  #SOLO PARA 'F' COBRO DE FACTURA / CUOTA  
  FechaCreditoSegunda={:type=>:numeric,:size=>8,:decimals=>0,:posi=>146,:posf=>153,:required=>false,:format=>'%Y%m%d',:filling_char=>'0',:desc=>"IFCHC2: FECHA SEGUNDO VENCIMIENTO. SOLO PARA 'F' COBRO DE FACTURA / CUOTA"}

  #ICEPTO: COMENTARIO DE CONCEPTO COBRADO / PAGADO  
  Comentario={:type=>:alfa,:size=>50,:posi=>154,:posf=>203,:required=>false,:filling_char=>' ',:desc=>'ICEPTO: COMENTARIO DE CONCEPTO COBRADO / PAGADO'}

  #INRREF: REFERENCIA OPERACION EMPRESA  
  ReferenciaOperacion={:type=>:alfa,:size=>15,:posi=>204,:posf=>218,:required=>false,:filling_char=>' ',:desc=>'INRREF: REFERENCIA OPERACION EMPRESA'}

  #IFECCA: FECHA DE CARGA DE TRANSACCION  
  FechaCarga={:type=>:numeric,:size=>8,:decimals=>0,:posi=>219,:posf=>226,:required=>false,:format=>'%Y%m%d',:filling_char=>'0',:desc=>'IFECCA: FECHA DE CARGA DE TRANSACCION'}

  #IHORCA: HORA DE CARGA DE TRANSACCION  
  HoraCarga={:type=>:numeric,:size=>6,:decimals=>0,:posi=>227,:posf=>232,:required=>false,:format=>'%H%M%S',:filling_char=>'0',:desc=>'IHORCA: HORA DE CARGA DE TRANSACCION'}

  #IUSUCA: NOMBRE DEL USUARIO QUE CARGO
  NombreUsuario={:type=>:alfa,:size=>10,:posi=>233,:posf=>242,:required=>false,:filling_char=>' ',:desc=>'IUSUCA: NOMBRE DEL USUARIO QUE CARGO'}
  
  #OBSERVACIONES GENERALES
  #-EL archivo a ser enviado debe estar en formato ASCII line secuencial, de ancho fijo, sin separadores de campos.
  #-Todos los campos numéricos deben estar justificados a la derecha, con ceros en las posiciones no significativas.
  #-Todos los campos alfa debe estar justificados a la izquierda.
  #-Si un campo numérico quedará vació. Debe rellenarse con ceros.
  #-Si un campo alfa quedará vació. Debe rellenarse con espacios.
  #-La Longitud del registro siempre deberá ser de 242 posiciones.
  #-Las posiciones decimales, forman parte del tamaño del campo. Por ejemplo: el campo IMTOTR debe contener:
  #-000000055020000 que es equivalente a 550.200,00 (quinientos cincuenta mil doscientos).
  #-Al final del archivo se debe agregar un registro de control (ITIREG = ‘C’) por cada cuenta de débito enviado en el
  #detalle (ICTDEB) colocando en el campo de Monto Transferencia (IMTOTR) el total a debitar a dicha cuenta. Estos
  #registros permitirán realizar un control de consistencia de la información suministrada. Cada registro de control debe
  #tener información en los campos: ITIREG, ICTDEB, IMTOTR y resto de los campos completar con ceros (los numéricos) y blancos (los alfa).
  #-Debe tener el nombre de TRANSFER.TXT

  #El parametro movimientos, debe poseer objetos que posean: monto, cuenta, y el documento del usuario
  #conf=
  #:tipo_registro=>:detalle,
  #:tipo_transferencia=>:pago_salarios
  #:hora_caga =>{:hora=>12,:minuto=>40}
  def initialize(usuario,movimientos,conf={})
    @tipo_registro = TipoRegistro[:values][conf[:tipo_registro]]
    @tipo_transferencia = TipoTransferencia[:values][conf[:tipo_transferencia]]
    c=conf[:codigo_empresa].to_i
    self.codigo_empresa = c.to_i
    self.cuenta_debito_empresa = conf[:cuenta_debito_empresa]
    self.numero_banco_credito = NumeroBancoCredito[:value]
    #@CuentaCredito utilizado al crear los registros
    @tipo = Tipo[:values][conf[:tipo]]
    #@orden_cheque utilizado en la generacion de los registros
    self.moneda = Moneda[:values][conf[:moneda]]
    #@monto_primero
    #@monto_segundo
    #@documento_persona
    self.tipo_factura = TipoFactura[:values][conf[:tipo_factura]]
    #@numero_factura'
    #@numero_cuota
    self.fecha_credito_primera = format(:fecha_credito_primera,conf)
    self.fecha_credito_segunda = format(:fecha_credito_segunda,conf)
    #@comentario=
    #@referencia_operacion
    self.fecha_carga = format(:fecha_carga,conf)
    self.hora_carga = format(:hora_carga,conf)
    self.nombre_usuario = usuario
    @ultimo_registro = nil
    @movimientos = movimientos.clone
    @movimientos_con_error=[]
    check_movimientos
    @registros = []
    #asignar_datos(conf)
  end
  def check_movimientos
    ok=true
    correctos=[]
    errados=[]
    self.movimientos.each do |m|      
      if cumple_condiciones_para_procesar(m)
        correctos<<m
      else
        errados<<m
      end
      @movimientos_con_error=errados
      @movimientos=correctos
    end
  end

  def cumple_condiciones_para_procesar(m)
    #match: checkea la longitud del numero de cuenta y que solo posea numeros
    #m.cuenta_numero.to_s.match("^[0-9]{1,#{CuentaCredito[:size]}}$").nil?
    #    puts "\n\n====================================================================="
    #    puts "!m.cuenta_deposito.empty?= #{!m.cuenta_deposito.empty?}"
    #    puts "!(m.monto_deposito.to_i<=0)= #{!(m.monto_deposito.to_i<=0)}"
    #    puts "(m.documento_deposito and  !m.documento_deposito.empty?)= #{(m.documento_deposito and !m.documento_deposito.empty?)}"
    #    puts "!m.nombre_orden.empty?= #{!m.nombre_orden.empty?}"
    #    puts "\n\n"
    ((!m.cuenta_deposito.empty? and !(m.monto_deposito.to_i<=0) and (m.documento_deposito and !m.documento_deposito.empty?) and !m.nombre_orden.empty?))
  end
  def format_value(val,rules)
    return val.to_s unless (rules and rules.keys.include?(:size) and rules.keys.include?(:type) and rules.keys.include?(:filling_char))
    case rules[:type]
    when :alfa #justificamos hacia la izquierda
      #val = val.to_s.truncate(rules[:size],:omission=>'')
      val = val.to_s[0..rules[:size]-1]
      missing_size = rules[:size] - val.to_s.size
      val + rules[:filling_char] * missing_size
    when :numeric #justificamos hacia la derecha
      if val.is_a?(String)
        val.gsub!('-','')
        val.gsub!('/','')
        val.gsub!(' ','')
      end
      val||=0.0
      val=sprintf("%.#{rules[:decimals]}f",val)
      val.gsub!('.','')
      val = val.to_s[0..rules[:size]-1]
      missing_size = rules[:size] - val.to_s.size
      rules[:filling_char] * missing_size + val
    end
  end

  def nombre_usuario=(nombre = NombreUsuario[:filling_char])
    @nombre_usuario=format_value(nombre,NombreUsuario)
  end

  def referencia_operacion=(ref = ReferenciaOperacion[:filling_char])
    @referencia_operacion=format_value(ref,ReferenciaOperacion)
  end

  def numero_cuota=(nro = NumeroCuota[:filling_char])
    @numero_cuota=format_value(nro,NumeroCuota)
  end

  def numero_factura=(nro = NumeroFactura[:filling_char])
    #FALTA LOGICA PARA PAGO PROVEEDORES, ETC.
    @numero_factura=format_value(nro,NumeroFactura)
  end

  def tipo_factura=(tipo = TipoFactura[:filling_char])
    #SOLO SE CONSIDERA PAGO DE SALARIOS
    #FALTA LOGICA PARA PAGO PROVEEDORES, ETC.
    @tipo_factura=format_value(tipo,TipoFactura)
  end

  def documento_persona=(doc = DocumentoPersona[:filling_char])
    @documento_persona=format_value(doc,DocumentoPersona)
  end

  def monto_segundo=(monto = MontoSegundo[:filling_char])
    #OBS: No se tienen en cuenta los decimales en el valor de 'monto'
    monto=monto.to_i.to_s
    @monto_segundo=format_value(monto,MontoSegundo)
  end

  def monto_primero=(monto = MontoPrimero[:filling_char])
    #OBS: No se tienen en cuenta los decimales en el valor de 'monto'
    monto=monto.to_i.to_s
    @monto_primero=format_value(monto,MontoPrimero)
  end

  def orden_cheque=(orden = OrdenCheque[:filling_char])
    @orden_cheque=format_value(orden,OrdenCheque)
  end
  
  def cuenta_credito=(nro = CuentaCredito[:filling_char])
    nro='0' if pago_en_cheque?
    @cuenta_credito=format_value(nro,CuentaCredito)
  end

  def pago_en_cheque?
    tipo==Tipo[:values][:cheque]
  end
 
  def numero_banco_credito=(nro = NumeroBancoCredito[:filling_char])
    @numero_banco_credito = format_value(nro,NumeroBancoCredito)
  end

  def cuenta_debito_empresa=(cta = CuentaDebitoEmpresa[:filling_char])
    @cuenta_debito_empresa = format_value(cta,CuentaDebitoEmpresa)
  end

  def codigo_empresa=(cd = CodigoEmpresa[:filling_char])
    @codigo_empresa=format_value(cd,CodigoEmpresa)
  end

  def format(key,conf)
    send('format_'+key.to_s,conf[key])
  end

  def format_fecha_carga(date)
    date = date.is_a?(Date) ? date.strftime(FechaCarga[:format]) : FechaCarga[:filling_char]
    missing_size=FechaCarga[:size]-date.size
    FechaCarga[:filling_char]*missing_size+date.to_s
  end

  def format_hora_carga(time_hash)
    time_hash[:hora]||=time_hash[:hour]
    time_hash[:minuto]||=time_hash[:minute]
#    puts "\n\n\n"
#    puts "params[:hora_carga] => #{time_hash.inspect}"
#    puts "\n\n\n"
    time = conf_hora_carga_ok?(time_hash) ? Time.mktime(2012,10,29,time_hash[:hora],time_hash[:minuto]).strftime(HoraCarga[:format]) : HoraCarga[:filling_char]
#    puts "\n\n\n"
#    puts "TIME  => #{time.inspect}"
#    puts "\n\n\n"
    missing_size=HoraCarga[:size]-time.size
    result=HoraCarga[:filling_char]*missing_size+time
#    puts "\n\n\n"
#    puts "result  => #{result.inspect}"
#    puts "\n\n\n"
    result
  end

  def format_fecha_credito_primera(date)
    date = date.is_a?(Date) ? date.strftime(FechaCreditoPrimera[:format]) : FechaCreditoPrimera[:filling_char]
    missing_size = FechaCreditoPrimera[:size]-date.size
    FechaCreditoPrimera[:filling_char]*missing_size+date
  end

  def format_fecha_credito_segunda(date)
    date = date.is_a?(Date) ? date.strftime(FechaCreditoSegunda[:format]) : FechaCreditoSegunda[:filling_char]
    missing_size = FechaCreditoSegunda[:size]-date.size
    FechaCreditoSegunda[:filling_char]*missing_size+date
  end

  def comentario=(comentario = Comentario[:filling_char])
    @comentario = format_value(comentario,Comentario)
  end

  def generar_registros
    self.detalle_de_registros=""
    total_deposito=0
    @registros=[]
    return unless @movimientos
    self.detalle_de_registros="Cantidad de registros: #{@movimientos.count+1}\n"
    @movimientos.each do |m|      
      total_deposito+= m.monto_deposito
      self.cuenta_credito = m.cuenta_deposito #cuenta del banco para el funcionario
      self.monto_primero = m.monto_deposito #valor a acreditar en la cuenta
      self.documento_persona = m.documento_deposito #documento del funcionario
      self.referencia_operacion = m.try(:referencia)
      self.comentario = m.try(:comentario)
      self.orden_cheque = m.nombre_orden
      self.numero_factura = m.nro_factura
      @registros<< generar_registro
    end
    @registros<<generar_registro_control(total_deposito)
    #puts self.detalle_de_registros
    @registros
  end

  def generar_registro_control(total)
    reg=[]
    CamposRegistroOrden.each do |the_method|
      puts "\n\n\n the_method => #{the_method}"
      the_alias=get_alias_for(the_method).to_s
      puts "\n\n\n the_alias => #{the_alias}"
      the_rules=eval(the_alias.titleize.gsub(' ',''))
      value= case the_method
      when :itireg 
        format_value(TipoRegistro[:values][:control],the_rules) 
      when :imtotr
        format_value(total,the_rules) 
      when :ictdeb
        format_value(self.cuenta_debito_empresa,the_rules)
      else
        format_value(nil,the_rules) 
      end
      reg << value

    end
    reg.join
  end

  def generar_registro
    reg=[]
    self.detalle_de_registros+="Registro nro #{@registros.count+1}"
    CamposRegistroOrden.each do |the_method|
      the_alias=get_alias_for(the_method).to_s
      the_rules=eval(the_alias.titleize.gsub(' ',''))
      value = send(the_method) || format_value(nil,the_rules)
      self.detalle_de_registros+=%Q{
      =======================================================
      CAMPO: #{the_alias}
      DESCRIPCION: #{the_rules[:desc]}
      VALOR INTRODUCIDO: #{value}
      LONGITUD: #{value.size}, longitud requerida es #{the_rules[:size]}
      RELLENAR CON: #{the_rules[:filling_char]}
      INICIA EN LA POSICION: #{the_rules[:posi]}
      TERMINA EN LA POSICION: #{the_rules[:posf]}
      VALORES PREDEFINIDOS: #{the_rules[:values].inspect.to_s}
      REQUERIDO: #{the_rules[:required].inspect}
      TIPO: #{the_rules[:type]}
      =======================================================
      }
      reg<<value
    end
    100.times{self.detalle_de_registros+="+"}
    reg.join
  end


  def get_alias_for(method)
    m=ItauTransfer.instance_methods(false).select{|m| ItauTransfer.instance_method(method)==ItauTransfer.instance_method(m) and m.to_s!= method.to_s}.first
  end

  def registro_ejemplo
    reg=[]
    my_total_size=0
    required_total_size=0
    CamposRegistroOrden.each do |the_method|
      the_alias=get_alias_for(the_method).to_s
      the_rules=eval(the_alias.titleize.gsub(' ',''))
      puts "---------------------------------------------------------------------------"
      puts "Let's see #{the_method}"
      puts "with alias #{the_alias}"
      puts "and this rules #{the_rules}"
      value = send(the_method) || format_value(nil,the_rules)
      my_size = value.size
      required_size=the_rules[:size]
      puts "My Size for #{the_method} is #{my_size}, required size is: #{required_size}"
      puts "---------------------------------------------------------------------------"
      reg<< value
      my_total_size+=my_size
      required_total_size+=required_size
    end
    puts "My total size is: #{my_total_size}\n"
    puts "Required total size is: #{required_total_size}"
    puts "I'm\n '#{reg.join}'"
    puts "---------------------------------------------------------------------------"
    puts my_total_size == required_total_size ? "I'm seem to be fine =D" : "Somethig is wrong with me =(..."
    puts "---------------------------------------------------------------------------"
    reg
  end

  def valid?
    # local_varibles
  end

  def conf_hora_carga_ok?(conf_hora_carga)
    conf_hora_carga.is_a? Hash and (0..23).include?(conf_hora_carga[:hora].to_i) and (0..59).include?(conf_hora_carga[:minuto].to_i)
  end

#  def asignar_datos(conf)
#    ids=movimientos.map(&:id)
#    f=conf[:fecha_credito_primera]
#    h=conf[:hora_carga]
#    fecha_hora=Time.mktime(f.year,f.month,f.day,h[:hour],h[:minute])
#    Pago.update_all(["fecha_hora_credito = ?, cuenta_empresa_id=?",fecha_hora,conf[:cuenta_debito_empresa_id]],["id in (?)",ids])
#  end
end